import java.util.Locale;

public class TestDemo {
    int count = 10;  //在方法外部的变量是什么呢————成员变量 JAVA中没有所谓的全局变量的说法
//选中要注释的代码段ctrl+shift+/ 进行注释和取消注释——块注释
//选中要注释的代码段ctrl+/ 行注释

    public static void main(String[] args) {
        float f = 19.9f;
        int i = 10;
        i = (int)f; //不转小数部分会丢失 虽然int float都是四个字节，但是float能表示的数据宽度更宽，可以表示整数和小数
        System.out.println(i);
        //小于四个字节都会强制提升为4个字节 同时两种不一样的数据类型进行运算时，会把其中一个较小的提升为较大的
        //主要原因：提高运算效率
        byte a = 10;
        byte b = 2;
        byte c = (byte)(a + b);// a b 运算时提升为Int型

        int a1 = 10;
        long b1 = 20L;
        int c1 = (int)(a1 + b1);// int被提升为long

        int z1 = 10;
        int z2 = 20;
        System.out.println("z1="+z1+" z2=" + z2);//z1=10 z2=20 这里+都表示字符串拼接哦 不是计算
        System.out.println("z1 + z2 = "+(z1+z2));// z1 + z2 = 30
        System.out.println(z1+z2+"hahahahaha");// 30hahahahaha
    }

    /**
     * 字符串类型 String
     *
     * @param args
     */
    public static void main9(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1);
        System.out.println(s2.length()); // 5
        System.out.println(s2.toUpperCase()); //WORLD
        System.out.println(s1+" "+s2); // s1+s2表示：将s1和s2进行拼接

        //字符串类型转换为整型
        String str = "1234";
        int a = Integer.parseInt(str);
        System.out.println(a+1); //1235

        //整型转换为字符串类型
        int i =1234;
        String ret = String.valueOf(i);
        String ret2 = i + "";//任何类型和字符串拼接最终都是字符串类型
        System.out.println(ret.length()); //4

        //逆置
        StringBuilder sb = new StringBuilder("hello");
        sb.reverse();
        System.out.println(sb);
    }



    /**
     * 布尔型变量boolean 在JAVA中只能有两个取值true false 没有 0假1真 的说法
     * boolean包装类Boolean
     * boolean非常特殊,JVM没有明确的大小
     * @param args
     */
    public static void main8(String[] args) {
        boolean flag = true;
        boolean flag2= false;
        System.out.println(flag);
        System.out.println(flag2);
    }


    /**
     * 字符型变量char 占用两个字节16位 （不是整数类型）
     * 不能表示负数 最大 2^16-1 范围是0-65535
     * 给一个整数输出的是该整数所对应的字符
     * Java 中使用 Unicode 表示字符 表示的种类更多 （C语言中使用ASCII字符集表示的范围小char仅一个字节）
     * 可以赋中文 因为一个中文是2个字节
     * char的包装类型为 Character
     * @param args
     */
    public static void main7(String[] args) {
        char ch = 'a';
        char ch1 = 'A';
        char ch2 = '晰'; //表示中文要指定一下是UTF-8编码
        char ch3 = 97; // a
        System.out.println(ch);
        System.out.println(ch1);
        System.out.println(ch2);
        System.out.println(ch3);
    }

    public static void main6(String[] args) {
        int a = 5;
        int b = 10;
        System.out.println(a/b);  //0
        System.out.println(a*1.0/b);  //0.5

        double c = 5;
        double d = 10;
        System.out.println(c/d); //0.5

        double num = 1.1;
        System.out.println(num*num);// 1.2100000000000002 计算机中，小数是没有精确数字的，99.9可能是99.999001
        //float 精确到小数点后6位 double精确到小数点后14位
    }


    /**
     * 单精度浮点类型赋值时需要加f:12.5f 表示是4个字节 所以一般用双精度浮点型double8个字节
     * 遵循浮点数存储方式
     * float -- Float
     * double -- Double
     * @param args
     */
    public static void main5(String[] args) {
        // float f = 12.5; 会报错，因为12.5默认为double类型占用八个字节，不能把8个字节的数据给4个字节
        float f = 12.5f;
        double d = 12.5;
        System.out.println(f);
        System.out.println(d);
    }


    /**
     * 字节型 byte：大小为1个字节8位
     * 可以表示正数和负数 -2^7~2^7-1  __ -128~127
     * byte对应的包装类型位Byte
     * @param args
     */
    public static void main4(String[] args) {
        byte a = 127;//编译器会自动进行检查你赋值的字面值常量是不是超过了数据类型所能表示的数据范围
        byte b = (byte)(a + 1);//这里加1超过了byte所能表示的范围,但是结果却显示-128
        byte c = (byte)(a + 2);//同理结果应为-127 强制类型转换 你为这次强转结果负责
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println("最大值:" + Byte.MAX_VALUE);
        System.out.println("最小值:" + Byte.MIN_VALUE);
    }


    /**
     * 短整型：大小为2个字节16位
     * 可以表示正数和负数
     * short包装类类型位Short
     * @param args
     */
    public static void main3(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println("最大值:" + Short.MAX_VALUE);
        System.out.println("最小值:" + Short.MIN_VALUE);
    }


    /**
     * 长整型：大小为8个字节64位 【可移植性强：不管是多少位的操作系统都占8个字节】
     * long可以表示正数和负数 首位为符号位
     * long对应的包装类类型为Long
     * @param args
     */
    public static void main2(String[] args) {
        //加个L标识长整型
        long a = 10L;
        System.out.println(a);
        System.out.println("最大值：" + Long.MAX_VALUE);
        System.out.println("最小值：" + Long.MIN_VALUE);
    }


    /**
     * 整型： 大小4个字节32位 【可移植性强：不管32位还是64位，int就是4个字节】
     * int 没有所谓的无符号整数，所以int可以表示正数和负数
     * 包装类：每个基本数据类型都会对应一个类类型 int包装类为 Integer
     * @param args
     */
    public static void main1(String[] args) {
        //局部变量使用时必须初始化 不初始化编译不会通过
        int a = 10;
        System.out.println(a);
        System.out.println("最大值：" + Integer.MAX_VALUE);
        System.out.println("最小值：" + Integer.MIN_VALUE);
    }
}
